Amiga ISO Collection/AmigaUtilCD2.iso/Programming/C/hf^k-1.dms/in.adf/Examples.Lha/Parser/Parser.c

C/C++ Source or Header | 1996-02-18 | 5.4 KB | 351 lines

#ifndef    PARSER_C
#define    PARSER_C

//    Short:        Command line parser for mathematical expressions.
//    Version:        $VER: Parser.c 1.0 (16.01.96)
//    Copyright:    Copyright © 1996 Constantin Rack. All rights reserved.


//    ========================================================= INCLUDES

#include    <ctype.h>                            //    Needed for isdigit()
#include    <iostream.h>                        //    Needed for standard I/O
#include    <string.h>                            //    Needed for string functions


//    ========================================================== DEFINES

enum    Consts                                    //    Some constant values
{
    FALSE        =    0,
    TRUE        =    1,
    Op_Num    =    5,                                //    Number of operators
};

enum    OperatorTypes
{
    Op_Err    =    -1,                            //    Bad operator
    Op_Add    =    0,                                //    +
    Op_Sub    =    1,                                //    -
    Op_Mul    =    2,                                //    *
    Op_Div    =    3,                                //    /
};

struct    Operator
{
    int    op_Type;                                //    Type of operator (see above)
    char*    op_Name;                                //    Operator as a string
};


//    ======================================================== VARIABLES

const char*    Version    =    "$VER: Parser 1.0 (16.01.96)";
char*            ActPtr    =    0;                    //    Actual text pointer
int            Error        =    FALSE;            //    Error indicator

struct    Operator    operators[Op_Num]    =
{
    {
        Op_Add,    "+"
    },

    {
        Op_Sub,    "-"
    },

    {
        Op_Mul,    "*"
    },

    {
        Op_Div,    "/"
    },
};


//    ======================================================= PROTOTYPES

long    Expression();
long    Factor();
long    Constant();
long    Operater();


//    ======================================================== FUNCTIONS


//    --------------------------------------------------------- FUNCTION
//    Operater()
//
//    Short:    Reads an operator and returns its value.
//    Needs:    ctype.h, string.h

long    Operater()
{
    long    result    =    0;
    long    i            =    0;
    char*    string    =    0;

    string    =    new char [80];
    result    =    Op_Err;

    if( string == 0 )
    {
        return    result;
    }

    while( *ActPtr != ' ' && i < 79 )
    {
        string[i++]    =    tolower( *ActPtr++ );
    }

    ActPtr++;

    string[i]    =    '\0';

    for(i=0;i<Op_Num;i++)
    {
        if( strcmp(operators[i].op_Name,string) == 0 )
        {
            result    =    operators[i].op_Type;
        }
    }

    delete    []    string;

    return result;
}


//    --------------------------------------------------------- FUNCTION
//    Constant()
//
//    Short:    Reads a constant number ("C-Tools", ISBN 3-89090-190-5)
//    Needs:    ctype.h

long    Constant()
{
    long    result    =    0;

    while( *ActPtr != 0 && isdigit(*ActPtr) != 0 )
    {
        result    =    (result * 10) + (*ActPtr++ - '0');
    }

    return result;
}

//    --------------------------------------------------------- FUNCTION
//    Factor()
//
//    Short:    Evaluates an expression. This function is recursive.
//    Needs:    ctype.h

long    Factor()
{
    long    result    =    0;
    long    sign        =    1;

    if( *ActPtr == 0 )
    {
        return result;
    }


    if( *ActPtr == '-' )
    {
        sign    =    -1;
        ActPtr++;
    }

    if( isdigit( *ActPtr ) != 0 )
    {
        result    =    Constant();
    }
    else
    {
        if( *ActPtr == '(' )
        {
            result    =    Expression();
        }
    }

    result    *=    sign;

    return    result;
}

//    --------------------------------------------------------- FUNCTION
//    Expression()
//
//    Short:    Evaluates a bracket expression.
//    Needs:    stream.h

long    Expression()
{
    long    result    =    0;
    long    op            =    0;

    if( *ActPtr == '(' )
    {
        ActPtr++;

        op                =    Operater();
        result        =    Factor();

        switch( op )
        {
            case    Op_Add:
                    {
                        while( *ActPtr++ != ')' )
                        {
                            result    +=    Factor();
                        }
                    }
                    break;

            case    Op_Sub:
                    {
                        while( *ActPtr++ != ')' )
                        {
                            result    -=    Factor();
                        }
                    }
                    break;

            case    Op_Mul:
                    {
                        while( *ActPtr++ != ')' )
                        {
                            result    *=    Factor();
                        }
                    }
                    break;

            case    Op_Div:
                    {
                        long    temp    =    0;

                        while( *ActPtr++ != ')' )
                        {
                            temp    =    Factor();

                            if( temp != 0 )
                            {
                                result    /=    temp;
                            }
                            else
                            {
                                cerr    <<    "** Division by zero\n";
                                Error    =    TRUE;
                            }
                        }
                    }
                    break;

            case    Op_Err:
            default:
                {
                        cerr    <<    "** Bad operator\n";
                        Error    =    TRUE;
                    }
                    break;
        }
    }
    else
    {
        if( *ActPtr == '?' )
        {
            cerr    <<    "This parser uses a simple praefix notation. Example:\n"
                    <<    "\t(+ 1 (* 2 (/ 10 5)))\n"
                    <<    "would have the result 5. So always write the operator "
                    <<    "first. Parser knows the following operators by now:\n";

            {
                int    i    =    0;

                for(i=0;i<Op_Num;i++)
                {
                    cerr    <<    operators[i].op_Name
                            <<    ", ";
                }

                cerr    <<    "\n";
            }

            cerr    <<    "\nCopyright © 1996 Constantin Rack. All rights reserved.\n";

            Error    =    TRUE;
        }
        else
        {
            cerr    <<    "** Bad command line\n";
            Error    =    TRUE;
        }
    }

    return    result;
}

//    --------------------------------------------------------- FUNCTION
//    main()
//
//    Short:    Main function of the parser.
//    Needs:    stream.h, string.h

int    main()
{
    int    okay        =    TRUE;
    long    result    =    0;
    char*    input        =    0;

    input    =    new char [256];

    if( input == 0 )
    {
        cerr    <<    "** Memory problem\n";
        return    5;
    }

    cout    <<    "Parser 1.0 (16.01.96)\n"
            <<    "Short:    Command line parser for mathematical expressions\n"
            <<    "Usage:    Press '?' for more information\n\n";

    while( okay )
    {
        cout    <<    "Expression: ";
        cin.getline(input,255);

        okay    =    strlen(input);

        if( okay > 0 )
        {
            ActPtr    =    &input[0];
            result    =    Expression();

            if( Error == 0 )
            {
                cout    <<    "Result: "
                        <<    result
                        <<    "\n";
            }
            else
            {
                Error    =    FALSE;
            }
        }
        else
        {
            cout    <<    "** Parser ended\n";
        }
    }

    delete    []    input;

    return    0;
}

#endif    //    PARSER_C